import Store from './vital-store/store';
import {
    getSongDetail,
    getLyrics
} from '../service/music-api';
import {
    parseLyrics
} from '../utils/parse-lyrics';

// getBackgroundAudioManager createInnerAudioContext

// 背景播放
const audioContext = wx.getBackgroundAudioManager({
    useWebAudioImplement: true
});
const playerStore = new Store({
    state: {
        id: 0,
        currentSong: {},
        totalTime: 0,
        lyricInfo: [],

        currentTime: 0,
        currentLyricIndex: 0,
        currentLyricText: "",

        isPlaying: true,

        // 播放模式：0: 循环播放 1: 单曲循环 2: 随机播放
        playModeIndex: 0,

        // 播放列表
        playListSongs: [],

        // 列表中当前播放歌曲的索引
        playListIndex: 0,
        isFirstPlay: true
    },
    actions: {

        // 根据歌曲id播放歌曲
        playMusicWithSongIdAction(ctx, {
            id,
            isRefresh
        }) {
            // 如果要播放的id和当前保存的id一样，并且不是强制刷新，说明是重新进入这个音乐，不需要重新播放
            if (ctx.id == id && !isRefresh) {
                // 刷新歌曲
                this.dispatch("changeMusicPlayStatusAction", true)
                return;
            }
            ctx.id = id;

            // 重置新的播放的状态
            ctx.isPlaying = true;
            ctx.currentSong = {};
            ctx.durationTime = 0;
            ctx.lyricInfo = [];
            ctx.currentTime = 0;
            ctx.currentLyricIndex = 0;
            ctx.currentLyricText = "";

            // 1.根据id请求数据
            // 请求歌曲详情
            getSongDetail(id).then(res => {
                ctx.currentSong = res.songs[0];
                ctx.totalTime = res.songs[0].dt;
                audioContext.title = res.songs[0].name;
            })
            // 请求歌词数据
            getLyrics(id).then(res => {
                const lyricString = res.lrc.lyric
                const lyrics = parseLyrics(lyricString)
                ctx.lyricInfo = lyrics
            })

            // 2.播放对应id的歌曲
            audioContext.stop()
            audioContext.src = `https://music.163.com/song/media/outer/url?id=${id}.mp3`
            audioContext.autoplay = true;
            audioContext.title = id;

            // 3.监听audioContext一些事件
            if (ctx.isFirstPlay) {
                this.dispatch("setupAudioContextListenerAction")
                ctx.isFirstPlay = false
            }
        },

        // 歌曲上下文事件监听
        setupAudioContextListenerAction(ctx) {
            // 监听歌曲可以播放
            audioContext.onCanplay(() => {
                audioContext.play()
            });

            // 监听时间改变，设置歌词
            audioContext.onTimeUpdate(() => {

                // 获取当前进度（秒）
                const currentTime = audioContext.currentTime;
                ctx.currentTime = currentTime * 1000;

                for (let i = 1; i < ctx.lyricInfo.length + 1; i++) {

                    // 找到第一个比当前时间长的歌词位置，这个歌词的前一个就是当前匹配的歌词
                    const curLyricsItem = ctx.lyricInfo[i];
                    if (currentTime * 1000 < curLyricsItem.time) {
                        const {
                            text
                        } = ctx.lyricInfo[i - 1];

                        if (text !== ctx.currentLyricText) {
                            ctx.currentLyricText = text;
                            ctx.currentLyricIndex = i - 1;
                        }
                        break;
                    }
                }
            });

            // 播放完毕，按照播放模式自动播放下一首
            audioContext.onEnded(() => {

                // 播放下一首
                this.dispatch('changeNewMusicAction', true);
            });

            // 暂停暂停
            audioContext.onPause(() => {
                ctx.isPlaying = false;
            });

            // 播放监听
            audioContext.onPlay(() => {
                ctx.isPlaying = true;
            });
        },

        // 改变播放状态（播放、暂停）
        changeMusicPlayStatusAction(ctx, isPlaying = true) {
            ctx.isPlaying = isPlaying;
            ctx.isPlaying ? audioContext.play() : audioContext.pause();
        },

        changeNewMusicAction(ctx, isNext = true) {
            // 获取当前索引
            let index = ctx.playListIndex;

            // 根据不同的播放模式, 获取下一首歌的索引
            switch (ctx.playModeIndex) {
                case 0: // 顺序播放
                    index = isNext ? index + 1 : index - 1;
                    if (index === -1) index = ctx.playListSongs.length - 1;
                    if (index === ctx.playListSongs.length) index = 0;
                    break
                case 1: // 单曲循环
                    break
                case 2: // 随机播放
                    index = Math.floor(Math.random() * ctx.playListSongs.length)
                    break
            }

            // 获取当前歌曲
            let currentSong = ctx.playListSongs[index];
            if (!currentSong) {
                currentSong = ctx.currentSong
            } else {
                // 记录最新的索引
                ctx.playListIndex = index
            }

            // 播放新的歌曲
            this.dispatch("playMusicWithSongIdAction", {
                id: currentSong.id,
                isRefresh: true
            })
        }
    }
});

export {
    playerStore,
    audioContext
}